< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:1207
Coverable lines:1207
Total lines:1865
Line coverage:0% (0 of 1207)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:169
Method coverage:0% (0 of 169)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetDisplayName()0%2100%
SetDisplayName(...)0%2100%
GetFlag(...)0%2100%
SetFlag(...)0%2100%
GetAllRowDescriptions()0%20400%
GetRowDescription(...)0%12300%
GetRowDescription(...)0%2100%
SetAllRowDescriptionsOrder(...)0%2100%
GetColumnDescription(...)0%30500%
GetColumnDescription(...)0%2100%
SetAllColumnDescriptionsOrder(...)0%2100%
GetAllColumnDescriptions()0%12300%
AssertColumnIDValid(...)0%20400%
AssertRowIDValid(...)0%30500%
SetColumnName(...)0%2100%
GetColumnName(...)0%2100%
SetRowName(...)0%2100%
GetRowName(...)0%2100%
GetRowNameRef(...)0%2100%
GetColumnNameRef(...)0%2100%
AddRow(...)0%2401500%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
SetTypeNameForObjectColumn[T](...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%6200%
ReSortRows[T](...)0%30500%
AddTypeNameEntryForUnityObjectColumn()0%12300%
RemoveTypeNameEntryForUnityObjectColumn(...)0%12300%
AssertObjectColumnIDValid(...)0%6200%
AddColumnInternal[T](...)0%4622100%
RemoveColumnInternal[T](...)0%12300%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%56700%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSortRowsArgValid(...)0%20400%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8using Object = UnityEngine.Object;
 9
 10namespace GDX.Tables
 11{
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : TableBase
 15    {
 016        internal static string UnityObjectString = typeof(Object).AssemblyQualifiedName;
 17
 018        [SerializeField] internal string DisplayName = "GDXStableTable";
 19
 20        [SerializeField] internal ArrayHolder<string>[] AllStringColumns;
 21        [SerializeField] internal ArrayHolder<bool>[] AllBoolColumns;
 22        [SerializeField] internal ArrayHolder<char>[] AllCharColumns;
 23        [SerializeField] internal ArrayHolder<sbyte>[] AllSbyteColumns;
 24        [SerializeField] internal ArrayHolder<byte>[] AllByteColumns;
 25        [SerializeField] internal ArrayHolder<short>[] AllShortColumns;
 26        [SerializeField] internal ArrayHolder<ushort>[] AllUshortColumns;
 27        [SerializeField] internal ArrayHolder<int>[] AllIntColumns;
 28        [SerializeField] internal ArrayHolder<uint>[] AllUintColumns;
 29        [SerializeField] internal ArrayHolder<long>[] AllLongColumns;
 30        [SerializeField] internal ArrayHolder<ulong>[] AllUlongColumns;
 31        [SerializeField] internal ArrayHolder<float>[] AllFloatColumns;
 32        [SerializeField] internal ArrayHolder<double>[] AllDoubleColumns;
 33        [SerializeField] internal ArrayHolder<Vector2>[] AllVector2Columns;
 34        [SerializeField] internal ArrayHolder<Vector3>[] AllVector3Columns;
 35        [SerializeField] internal ArrayHolder<Vector4>[] AllVector4Columns;
 36        [SerializeField] internal ArrayHolder<Vector2Int>[] AllVector2IntColumns;
 37        [SerializeField] internal ArrayHolder<Vector3Int>[] AllVector3IntColumns;
 38        [SerializeField] internal ArrayHolder<Quaternion>[] AllQuaternionColumns;
 39        [SerializeField] internal ArrayHolder<Rect>[] AllRectColumns;
 40        [SerializeField] internal ArrayHolder<RectInt>[] AllRectIntColumns;
 41        [SerializeField] internal ArrayHolder<Color>[] AllColorColumns;
 42        [SerializeField] internal ArrayHolder<LayerMask>[] AllLayerMaskColumns;
 43        [SerializeField] internal ArrayHolder<Bounds>[] AllBoundsColumns;
 44        [SerializeField] internal ArrayHolder<BoundsInt>[] AllBoundsIntColumns;
 45        [SerializeField] internal ArrayHolder<Hash128>[] AllHash128Columns;
 46        [SerializeField] internal ArrayHolder<Gradient>[] AllGradientColumns;
 47        [SerializeField] internal ArrayHolder<AnimationCurve>[] AllAnimationCurveColumns;
 48        [SerializeField] internal ArrayHolder<Object>[] AllObjectRefColumns;
 49        [SerializeField] internal string[] AllObjectRefTypeNames;
 50
 51        [SerializeField]
 052        internal ArrayHolder<string>[]
 53            AllColumnNames =
 54                new ArrayHolder<string>[Serializable
 55                    .SerializableTypesCount]; // Contains the name of each column of each type. Ordered by Serializable.
 56
 57        [SerializeField] internal int[] RowIDToDenseIndexMap;
 58        [SerializeField] internal int[] RowDenseIndexToIDMap;
 59        [SerializeField] internal string[] RowNames;
 60        [SerializeField] internal int RowEntriesFreeListHead;
 61
 62        [SerializeField] internal int RowCount;
 63
 64        [SerializeField] internal ColumnEntry[] ColumnIDToDenseIndexMap;
 65        [SerializeField] internal int[] ColumnIDToSortOrderMap;
 66        [SerializeField] internal int[] SortedOrderToColumnIDMap;
 67
 68        // TODO move with other block
 69        [SerializeField]
 070        ArrayHolder<int>[] ColumnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableTypesCount];
 71
 72        [SerializeField] internal int ColumnEntriesFreeListHead;
 73
 74        [SerializeField] internal int CombinedColumnCount;
 75
 076        [SerializeField] internal ulong DataVersion = 1;
 77
 78        [SerializeField] BitArray8 SettingsFlags;
 79
 80        public override ulong GetDataVersion()
 081        {
 082            return DataVersion;
 083        }
 84
 85        /// <inheritdoc />
 86        public override int GetColumnCount()
 087        {
 088            return CombinedColumnCount;
 089        }
 90
 91        /// <inheritdoc />
 92        public override int GetRowCount()
 093        {
 094            return RowCount;
 095        }
 96
 97        public override string GetDisplayName()
 098        {
 099            return DisplayName;
 0100        }
 101
 102        public override void SetDisplayName(string displayName)
 0103        {
 0104            DisplayName = displayName;
 0105        }
 106
 107        public override bool GetFlag(Flags flag)
 0108        {
 0109            return SettingsFlags[(byte)flag];
 0110        }
 111
 112        public override void SetFlag(Flags flag, bool toggle)
 0113        {
 0114            SettingsFlags[(byte)flag] = toggle;
 0115        }
 116
 117        public override RowDescription[] GetAllRowDescriptions()
 0118        {
 0119            if (CombinedColumnCount == 0 || RowCount == 0)
 0120            {
 0121                return null;
 122            }
 123
 0124            RowDescription[] returnArray = new RowDescription[RowCount];
 0125            for (int i = 0; i < RowCount; i++)
 0126            {
 0127                returnArray[i].InternalIndex = RowDenseIndexToIDMap[i];
 0128                returnArray[i].Name = RowNames[i];
 0129            }
 130
 0131            return returnArray;
 0132        }
 133
 134        public override RowDescription GetRowDescription(string name)
 0135        {
 0136            for (int i = 0; i < RowCount; i++)
 0137            {
 0138                string nameAt = RowNames[i];
 139
 0140                if (nameAt == name)
 0141                {
 0142                    return new RowDescription { InternalIndex = RowDenseIndexToIDMap[i], Name = nameAt };
 143                }
 0144            }
 145
 0146            throw new ArgumentException("Row with name " + name + " does not exist in the table");
 0147        }
 148
 149        public override RowDescription GetRowDescription(int order)
 0150        {
 0151            return new RowDescription { InternalIndex = RowDenseIndexToIDMap[order], Name = RowNames[order] };
 0152        }
 153
 154        public override void SetAllRowDescriptionsOrder(RowDescription[] orderedRows)
 0155        {
 156            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0157            throw new NotImplementedException();
 158        }
 159
 160        public override ColumnDescription GetColumnDescription(string name)
 0161        {
 0162            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 0163            {
 0164                string[] columnNames = AllColumnNames[i].TArray;
 165
 0166                if (columnNames != null)
 0167                {
 0168                    for (int j = 0; j < columnNames.Length; j++)
 0169                    {
 0170                        string nameAt = columnNames[j];
 171
 0172                        if (name == nameAt)
 0173                        {
 0174                            int columnID = ColumnDenseIndexToIDMap[i].TArray[j];
 175
 0176                            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 0177                            return new ColumnDescription
 178                            {
 179                                InternalIndex = columnID, Name = nameAt, Type = columnEntry.ColumnType
 180                            };
 181                        }
 0182                    }
 0183                }
 0184            }
 185
 0186            throw new ArgumentException("Column with name " + name + " does not exist in the table");
 0187        }
 188
 189        public override ColumnDescription GetColumnDescription(int order)
 0190        {
 0191            int idAtOrderedIndex = SortedOrderToColumnIDMap[order];
 0192            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[idAtOrderedIndex];
 193
 0194            string columnName = AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 195
 0196            return new ColumnDescription
 197            {
 198                InternalIndex = idAtOrderedIndex, Name = columnName, Type = columnEntry.ColumnType
 199            };
 0200        }
 201
 202        public override void SetAllColumnDescriptionsOrder(ColumnDescription[] orderedColumns)
 0203        {
 204            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0205            throw new NotImplementedException();
 206        }
 207
 208        /// <inheritdoc />
 209        public override ColumnDescription[] GetAllColumnDescriptions()
 0210        {
 0211            if (CombinedColumnCount == 0)
 0212            {
 0213                return null;
 214            }
 215
 0216            ColumnDescription[] returnArray = new ColumnDescription[CombinedColumnCount];
 217
 0218            for (int i = 0; i < CombinedColumnCount; i++)
 0219            {
 0220                int columnID = SortedOrderToColumnIDMap[i];
 0221                AssertColumnIDValid(columnID);
 0222                ref ColumnEntry entryForID = ref ColumnIDToDenseIndexMap[columnID];
 0223                ref ArrayHolder<string> nameColumnsForType = ref AllColumnNames[(int)entryForID.ColumnType];
 224
 0225                string name = nameColumnsForType[entryForID.ColumnDenseIndex];
 226
 0227                returnArray[i] = new ColumnDescription
 228                {
 229                    Name = name, InternalIndex = columnID, Type = entryForID.ColumnType
 230                };
 0231            }
 232
 0233            return returnArray;
 0234        }
 235
 236        internal void AssertColumnIDValid(int columnID)
 0237        {
 0238            if (columnID < 0 || columnID >= ColumnIDToDenseIndexMap.Length)
 0239            {
 0240                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 241            }
 242
 0243            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 244
 0245            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0246            {
 0247                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 248            }
 0249        }
 250
 251        internal void AssertRowIDValid(int rowID)
 0252        {
 0253            if (rowID < 0 || rowID >= RowIDToDenseIndexMap.Length)
 0254            {
 0255                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 256            }
 257
 0258            int rowIndex = RowIDToDenseIndexMap[rowID];
 259
 0260            if (rowIndex >= RowCount || rowIndex < 0)
 0261            {
 0262                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 263            }
 0264        }
 265
 266        public override void SetColumnName(string columnName, int column)
 0267        {
 0268            AssertColumnIDValid(column);
 0269            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[column];
 0270            AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex] = columnName;
 0271        }
 272
 273        public override string GetColumnName(int column)
 0274        {
 0275            AssertColumnIDValid(column);
 0276            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[column];
 0277            return AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0278        }
 279
 280        public override void SetRowName(string rowName, int row)
 0281        {
 0282            AssertRowIDValid(row);
 0283            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0284            RowNames[rowDenseIndex] = rowName;
 0285        }
 286
 287        public override string GetRowName(int row)
 0288        {
 0289            AssertRowIDValid(row);
 0290            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0291            return RowNames[rowDenseIndex];
 0292        }
 293
 294        public ref string GetRowNameRef(int row)
 0295        {
 0296            AssertRowIDValid(row);
 0297            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0298            return ref RowNames[rowDenseIndex];
 0299        }
 300
 301        public ref string GetColumnNameRef(int columnID)
 0302        {
 0303            AssertColumnIDValid(columnID);
 0304            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 0305            return ref AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0306        }
 307
 308
 309        public override int AddRow(string rowName = null, int insertAtRowID = -1)
 0310        {
 0311            if (insertAtRowID >= 0)
 0312            {
 0313                AssertRowIDValid(insertAtRowID);
 0314            }
 315
 0316            int rowID = RowEntriesFreeListHead;
 0317            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0318            if (rowID >= rowIDToDenseIndexMapLength)
 0319            {
 0320                int newSize = rowID * 2;
 0321                newSize = newSize == 0 ? 1 : newSize;
 0322                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0323                for (int i = rowID; i < newSize; i++)
 0324                {
 0325                    RowIDToDenseIndexMap[i] = i + 1;
 0326                }
 0327            }
 328
 0329            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0330            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 0331            Array.Resize(ref RowNames, denseIndexToIDMapLength + 1);
 332
 0333            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 334
 0335            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0336            {
 0337                int currentRowID = RowDenseIndexToIDMap[i - 1];
 0338                RowDenseIndexToIDMap[i] = currentRowID;
 339
 0340                RowIDToDenseIndexMap[currentRowID] = i;
 341
 0342                RowNames[i] = RowNames[i - 1];
 0343            }
 344
 0345            RowEntriesFreeListHead = RowIDToDenseIndexMap[rowID];
 0346            RowIDToDenseIndexMap[rowID] = insertAt;
 0347            RowDenseIndexToIDMap[insertAt] = rowID;
 0348            RowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 349
 0350            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, 1);
 0351            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, 1);
 0352            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, 1);
 0353            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, 1);
 0354            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, 1);
 0355            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, 1);
 0356            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, 1);
 0357            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, 1);
 0358            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, 1);
 0359            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, 1);
 0360            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, 1);
 0361            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, 1);
 0362            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, 1);
 0363            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, 1);
 0364            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, 1);
 0365            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, 1);
 0366            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, 1);
 0367            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, 1);
 0368            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, 1);
 0369            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, 1);
 0370            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, 1);
 0371            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, 1);
 0372            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, 1);
 0373            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, 1);
 0374            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, 1);
 0375            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, 1);
 0376            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, 1);
 0377            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, 1);
 0378            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, 1);
 379
 0380            ++RowCount;
 0381            DataVersion++;
 382
 0383            return rowID;
 0384        }
 385
 386        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0387        {
 0388            if (insertAtRowID >= 0)
 0389            {
 0390                AssertRowIDValid(insertAtRowID);
 0391            }
 392
 0393            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0394            int newCount = RowCount + numberOfNewRows;
 0395            if (newCount > rowIDToDenseIndexMapLength)
 0396            {
 0397                int newSize = newCount;
 0398                --newSize;
 0399                newSize |= newSize >> 1;
 0400                newSize |= newSize >> 2;
 0401                newSize |= newSize >> 4;
 0402                newSize |= newSize >> 8;
 0403                newSize |= newSize >> 16;
 0404                ++newSize;
 405
 0406                newSize = newSize == 0 ? 1 : newSize;
 0407                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0408                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0409                {
 0410                    RowIDToDenseIndexMap[i] = i + 1;
 0411                }
 0412            }
 413
 0414            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0415            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0416            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 417
 0418            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 419
 0420            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0421            {
 0422                int currentRowID = RowDenseIndexToIDMap[i - numberOfNewRows];
 0423                RowDenseIndexToIDMap[i] = currentRowID;
 424
 0425                RowIDToDenseIndexMap[currentRowID] = i;
 426
 0427                rowNames[i] = rowNames[i - numberOfNewRows];
 0428            }
 429
 0430            int freeListHead = RowEntriesFreeListHead;
 431
 0432            for (int i = 0; i < numberOfNewRows; i++)
 0433            {
 0434                int rowID = freeListHead;
 0435                freeListHead = RowIDToDenseIndexMap[rowID];
 0436                RowIDToDenseIndexMap[rowID] = insertAt + i;
 0437                RowDenseIndexToIDMap[insertAt + i] = rowID;
 0438            }
 439
 0440            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0441            string emptyString = string.Empty;
 0442            for (int i = 0; i < numberOfNewRowNames; i++)
 0443            {
 0444                string currentRowName = rowNames[i];
 0445                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0446                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0447            }
 448
 0449            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0450            {
 0451                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0452                rowNames[insertAt + i] = rowIDAt.ToString();
 0453            }
 454
 0455            RowEntriesFreeListHead = freeListHead;
 456
 0457            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, numberOfNewRows);
 0458            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, numberOfNewRows);
 0459            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, numberOfNewRows);
 0460            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, numberOfNewRows);
 0461            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, numberOfNewRows);
 0462            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, numberOfNewRows);
 0463            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, numberOfNewRows);
 0464            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, numberOfNewRows);
 0465            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, numberOfNewRows);
 0466            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, numberOfNewRows);
 486
 0487            RowCount += numberOfNewRows;
 0488            DataVersion++;
 0489        }
 490
 491        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0492        {
 0493            if (insertAtRowID >= 0)
 0494            {
 0495                AssertRowIDValid(insertAtRowID);
 0496            }
 497
 0498            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0499            int newCount = RowCount + numberOfNewRows;
 0500            if (newCount > rowIDToDenseIndexMapLength)
 0501            {
 0502                int newSize = newCount;
 0503                --newSize;
 0504                newSize |= newSize >> 1;
 0505                newSize |= newSize >> 2;
 0506                newSize |= newSize >> 4;
 0507                newSize |= newSize >> 8;
 0508                newSize |= newSize >> 16;
 0509                ++newSize;
 510
 0511                newSize = newSize == 0 ? 1 : newSize;
 0512                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0513                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0514                {
 0515                    RowIDToDenseIndexMap[i] = i + 1;
 0516                }
 0517            }
 518
 0519            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0520            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 521
 0522            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 523
 0524            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0525            {
 0526                int currentRowID = RowDenseIndexToIDMap[i - numberOfNewRows];
 0527                RowDenseIndexToIDMap[i] = currentRowID;
 528
 0529                RowIDToDenseIndexMap[currentRowID] = i;
 530
 0531                rowNames[i] = rowNames[i - numberOfNewRows];
 0532            }
 533
 0534            int freeListHead = RowEntriesFreeListHead;
 535
 0536            for (int i = 0; i < numberOfNewRows; i++)
 0537            {
 0538                int rowID = freeListHead;
 0539                freeListHead = RowIDToDenseIndexMap[rowID];
 0540                RowIDToDenseIndexMap[rowID] = insertAt + i;
 0541                RowDenseIndexToIDMap[insertAt + i] = rowID;
 0542                rowIDs[i] = rowID;
 0543            }
 544
 0545            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0546            for (int i = 0; i < numberOfNewRowNames; i++)
 0547            {
 0548                string currentRowName = rowNames[i];
 0549                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0550                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0551            }
 552
 0553            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0554            {
 0555                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0556                rowNames[insertAt + i] = rowIDAt.ToString();
 0557            }
 558
 0559            RowEntriesFreeListHead = freeListHead;
 560
 0561            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, numberOfNewRows);
 0562            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, numberOfNewRows);
 0563            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, numberOfNewRows);
 0564            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, numberOfNewRows);
 0565            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, numberOfNewRows);
 0566            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, numberOfNewRows);
 0567            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, numberOfNewRows);
 0568            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, numberOfNewRows);
 0569            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, numberOfNewRows);
 590
 0591            RowCount += numberOfNewRows;
 0592            DataVersion++;
 0593        }
 594
 595        public override void RemoveRow(int rowID)
 0596        {
 0597            AssertRowIDValid(rowID);
 0598            int rowDenseIndex = RowIDToDenseIndexMap[rowID];
 0599            for (int i = rowDenseIndex + 1; i < RowCount; i++)
 0600            {
 0601                int currentRowID = RowDenseIndexToIDMap[i];
 0602                RowIDToDenseIndexMap[currentRowID] = i - 1;
 0603                RowDenseIndexToIDMap[i - 1] = currentRowID;
 0604                RowNames[i - 1] = RowNames[i];
 0605            }
 606
 0607            RowIDToDenseIndexMap[rowID] = RowEntriesFreeListHead;
 0608            RowEntriesFreeListHead = rowID;
 0609            Array.Resize(ref RowDenseIndexToIDMap, RowCount - 1);
 0610            Array.Resize(ref RowNames, RowCount - 1);
 611
 0612            DeleteRowsOfTypeInternal(ref AllStringColumns, rowID, 1);
 0613            DeleteRowsOfTypeInternal(ref AllBoolColumns, rowID, 1);
 0614            DeleteRowsOfTypeInternal(ref AllCharColumns, rowID, 1);
 0615            DeleteRowsOfTypeInternal(ref AllSbyteColumns, rowID, 1);
 0616            DeleteRowsOfTypeInternal(ref AllByteColumns, rowID, 1);
 0617            DeleteRowsOfTypeInternal(ref AllShortColumns, rowID, 1);
 0618            DeleteRowsOfTypeInternal(ref AllUshortColumns, rowID, 1);
 0619            DeleteRowsOfTypeInternal(ref AllIntColumns, rowID, 1);
 0620            DeleteRowsOfTypeInternal(ref AllUintColumns, rowID, 1);
 0621            DeleteRowsOfTypeInternal(ref AllLongColumns, rowID, 1);
 0622            DeleteRowsOfTypeInternal(ref AllUlongColumns, rowID, 1);
 0623            DeleteRowsOfTypeInternal(ref AllFloatColumns, rowID, 1);
 0624            DeleteRowsOfTypeInternal(ref AllDoubleColumns, rowID, 1);
 0625            DeleteRowsOfTypeInternal(ref AllVector2Columns, rowID, 1);
 0626            DeleteRowsOfTypeInternal(ref AllVector3Columns, rowID, 1);
 0627            DeleteRowsOfTypeInternal(ref AllVector4Columns, rowID, 1);
 0628            DeleteRowsOfTypeInternal(ref AllVector2IntColumns, rowID, 1);
 0629            DeleteRowsOfTypeInternal(ref AllVector3IntColumns, rowID, 1);
 0630            DeleteRowsOfTypeInternal(ref AllQuaternionColumns, rowID, 1);
 0631            DeleteRowsOfTypeInternal(ref AllRectColumns, rowID, 1);
 0632            DeleteRowsOfTypeInternal(ref AllRectIntColumns, rowID, 1);
 0633            DeleteRowsOfTypeInternal(ref AllColorColumns, rowID, 1);
 0634            DeleteRowsOfTypeInternal(ref AllLayerMaskColumns, rowID, 1);
 0635            DeleteRowsOfTypeInternal(ref AllBoundsColumns, rowID, 1);
 0636            DeleteRowsOfTypeInternal(ref AllBoundsIntColumns, rowID, 1);
 0637            DeleteRowsOfTypeInternal(ref AllHash128Columns, rowID, 1);
 0638            DeleteRowsOfTypeInternal(ref AllGradientColumns, rowID, 1);
 0639            DeleteRowsOfTypeInternal(ref AllAnimationCurveColumns, rowID, 1);
 0640            DeleteRowsOfTypeInternal(ref AllObjectRefColumns, rowID, 1);
 641
 0642            --RowCount;
 0643            DataVersion++;
 0644        }
 645
 646        public override int AddColumn(Serializable.SerializableTypes columnType, string columnName,
 647            int insertAtColumnID = -1)
 0648        {
 0649            switch (columnType)
 650            {
 651                case Serializable.SerializableTypes.String:
 0652                    return AddColumnInternal(columnName, ref AllStringColumns, Serializable.SerializableTypes.String,
 653                        insertAtColumnID);
 654                case Serializable.SerializableTypes.Char:
 0655                    return AddColumnInternal(columnName, ref AllCharColumns, Serializable.SerializableTypes.Char,
 656                        insertAtColumnID);
 657                case Serializable.SerializableTypes.Bool:
 0658                    return AddColumnInternal(columnName, ref AllBoolColumns, Serializable.SerializableTypes.Bool,
 659                        insertAtColumnID);
 660                case Serializable.SerializableTypes.SByte:
 0661                    return AddColumnInternal(columnName, ref AllSbyteColumns, Serializable.SerializableTypes.SByte,
 662                        insertAtColumnID);
 663                case Serializable.SerializableTypes.Byte:
 0664                    return AddColumnInternal(columnName, ref AllByteColumns, Serializable.SerializableTypes.Byte,
 665                        insertAtColumnID);
 666                case Serializable.SerializableTypes.Short:
 0667                    return AddColumnInternal(columnName, ref AllShortColumns, Serializable.SerializableTypes.Short,
 668                        insertAtColumnID);
 669                case Serializable.SerializableTypes.UShort:
 0670                    return AddColumnInternal(columnName, ref AllUshortColumns, Serializable.SerializableTypes.UShort,
 671                        insertAtColumnID);
 672                case Serializable.SerializableTypes.Int:
 0673                    return AddColumnInternal(columnName, ref AllIntColumns, Serializable.SerializableTypes.Int,
 674                        insertAtColumnID);
 675                case Serializable.SerializableTypes.UInt:
 0676                    return AddColumnInternal(columnName, ref AllUintColumns, Serializable.SerializableTypes.UInt,
 677                        insertAtColumnID);
 678                case Serializable.SerializableTypes.Long:
 0679                    return AddColumnInternal(columnName, ref AllLongColumns, Serializable.SerializableTypes.Long,
 680                        insertAtColumnID);
 681                case Serializable.SerializableTypes.ULong:
 0682                    return AddColumnInternal(columnName, ref AllUlongColumns, Serializable.SerializableTypes.ULong,
 683                        insertAtColumnID);
 684                case Serializable.SerializableTypes.Float:
 0685                    return AddColumnInternal(columnName, ref AllFloatColumns, Serializable.SerializableTypes.Float,
 686                        insertAtColumnID);
 687                case Serializable.SerializableTypes.Double:
 0688                    return AddColumnInternal(columnName, ref AllDoubleColumns, Serializable.SerializableTypes.Double,
 689                        insertAtColumnID);
 690                case Serializable.SerializableTypes.Vector2:
 0691                    return AddColumnInternal(columnName, ref AllVector2Columns, Serializable.SerializableTypes.Vector2,
 692                        insertAtColumnID);
 693                case Serializable.SerializableTypes.Vector3:
 0694                    return AddColumnInternal(columnName, ref AllVector3Columns, Serializable.SerializableTypes.Vector3,
 695                        insertAtColumnID);
 696                case Serializable.SerializableTypes.Vector4:
 0697                    return AddColumnInternal(columnName, ref AllVector4Columns, Serializable.SerializableTypes.Vector4,
 698                        insertAtColumnID);
 699                case Serializable.SerializableTypes.Vector2Int:
 0700                    return AddColumnInternal(columnName, ref AllVector2IntColumns,
 701                        Serializable.SerializableTypes.Vector2Int, insertAtColumnID);
 702                case Serializable.SerializableTypes.Vector3Int:
 0703                    return AddColumnInternal(columnName, ref AllVector3IntColumns,
 704                        Serializable.SerializableTypes.Vector3Int, insertAtColumnID);
 705                case Serializable.SerializableTypes.Quaternion:
 0706                    return AddColumnInternal(columnName, ref AllQuaternionColumns,
 707                        Serializable.SerializableTypes.Quaternion, insertAtColumnID);
 708                case Serializable.SerializableTypes.Rect:
 0709                    return AddColumnInternal(columnName, ref AllRectColumns, Serializable.SerializableTypes.Rect,
 710                        insertAtColumnID);
 711                case Serializable.SerializableTypes.RectInt:
 0712                    return AddColumnInternal(columnName, ref AllRectIntColumns, Serializable.SerializableTypes.RectInt,
 713                        insertAtColumnID);
 714                case Serializable.SerializableTypes.Color:
 0715                    return AddColumnInternal(columnName, ref AllColorColumns, Serializable.SerializableTypes.Color,
 716                        insertAtColumnID);
 717                case Serializable.SerializableTypes.LayerMask:
 0718                    return AddColumnInternal(columnName, ref AllLayerMaskColumns,
 719                        Serializable.SerializableTypes.LayerMask, insertAtColumnID);
 720                case Serializable.SerializableTypes.Bounds:
 0721                    return AddColumnInternal(columnName, ref AllBoundsColumns, Serializable.SerializableTypes.Bounds,
 722                        insertAtColumnID);
 723                case Serializable.SerializableTypes.BoundsInt:
 0724                    return AddColumnInternal(columnName, ref AllBoundsIntColumns,
 725                        Serializable.SerializableTypes.BoundsInt, insertAtColumnID);
 726                case Serializable.SerializableTypes.Hash128:
 0727                    return AddColumnInternal(columnName, ref AllHash128Columns, Serializable.SerializableTypes.Hash128,
 728                        insertAtColumnID);
 729                case Serializable.SerializableTypes.Gradient:
 0730                    return AddColumnInternal(columnName, ref AllGradientColumns,
 731                        Serializable.SerializableTypes.Gradient, insertAtColumnID);
 732                case Serializable.SerializableTypes.AnimationCurve:
 0733                    return AddColumnInternal(columnName, ref AllAnimationCurveColumns,
 734                        Serializable.SerializableTypes.AnimationCurve, insertAtColumnID);
 735                case Serializable.SerializableTypes.Object:
 0736                    return AddColumnInternal(columnName, ref AllObjectRefColumns, Serializable.SerializableTypes.Object,
 737                        insertAtColumnID);
 738            }
 739
 0740            return -1;
 0741        }
 742
 743        public override void RemoveColumn(Serializable.SerializableTypes columnType, int columnID)
 0744        {
 0745            switch (columnType)
 746            {
 747                case Serializable.SerializableTypes.String:
 0748                    RemoveColumnInternal(ref AllStringColumns, Serializable.SerializableTypes.String, columnID);
 0749                    break;
 750                case Serializable.SerializableTypes.Char:
 0751                    RemoveColumnInternal(ref AllCharColumns, Serializable.SerializableTypes.Char, columnID);
 0752                    break;
 753                case Serializable.SerializableTypes.Bool:
 0754                    RemoveColumnInternal(ref AllBoolColumns, Serializable.SerializableTypes.Bool, columnID);
 0755                    break;
 756                case Serializable.SerializableTypes.SByte:
 0757                    RemoveColumnInternal(ref AllSbyteColumns, Serializable.SerializableTypes.SByte, columnID);
 0758                    break;
 759                case Serializable.SerializableTypes.Byte:
 0760                    RemoveColumnInternal(ref AllByteColumns, Serializable.SerializableTypes.Byte, columnID);
 0761                    break;
 762                case Serializable.SerializableTypes.Short:
 0763                    RemoveColumnInternal(ref AllShortColumns, Serializable.SerializableTypes.Short, columnID);
 0764                    break;
 765                case Serializable.SerializableTypes.UShort:
 0766                    RemoveColumnInternal(ref AllUshortColumns, Serializable.SerializableTypes.UShort, columnID);
 0767                    break;
 768                case Serializable.SerializableTypes.Int:
 0769                    RemoveColumnInternal(ref AllIntColumns, Serializable.SerializableTypes.Int, columnID);
 0770                    break;
 771                case Serializable.SerializableTypes.UInt:
 0772                    RemoveColumnInternal(ref AllUintColumns, Serializable.SerializableTypes.UInt, columnID);
 0773                    break;
 774                case Serializable.SerializableTypes.Long:
 0775                    RemoveColumnInternal(ref AllLongColumns, Serializable.SerializableTypes.Long, columnID);
 0776                    break;
 777                case Serializable.SerializableTypes.ULong:
 0778                    RemoveColumnInternal(ref AllUlongColumns, Serializable.SerializableTypes.ULong, columnID);
 0779                    break;
 780                case Serializable.SerializableTypes.Float:
 0781                    RemoveColumnInternal(ref AllFloatColumns, Serializable.SerializableTypes.Float, columnID);
 0782                    break;
 783                case Serializable.SerializableTypes.Double:
 0784                    RemoveColumnInternal(ref AllDoubleColumns, Serializable.SerializableTypes.Double, columnID);
 0785                    break;
 786                case Serializable.SerializableTypes.Vector2:
 0787                    RemoveColumnInternal(ref AllVector2Columns, Serializable.SerializableTypes.Vector2, columnID);
 0788                    break;
 789                case Serializable.SerializableTypes.Vector3:
 0790                    RemoveColumnInternal(ref AllVector3Columns, Serializable.SerializableTypes.Vector3, columnID);
 0791                    break;
 792                case Serializable.SerializableTypes.Vector4:
 0793                    RemoveColumnInternal(ref AllVector4Columns, Serializable.SerializableTypes.Vector4, columnID);
 0794                    break;
 795                case Serializable.SerializableTypes.Vector2Int:
 0796                    RemoveColumnInternal(ref AllVector2IntColumns, Serializable.SerializableTypes.Vector2Int, columnID);
 0797                    break;
 798                case Serializable.SerializableTypes.Vector3Int:
 0799                    RemoveColumnInternal(ref AllVector3IntColumns, Serializable.SerializableTypes.Vector3Int, columnID);
 0800                    break;
 801                case Serializable.SerializableTypes.Quaternion:
 0802                    RemoveColumnInternal(ref AllQuaternionColumns, Serializable.SerializableTypes.Quaternion, columnID);
 0803                    break;
 804                case Serializable.SerializableTypes.Rect:
 0805                    RemoveColumnInternal(ref AllRectColumns, Serializable.SerializableTypes.Rect, columnID);
 0806                    break;
 807                case Serializable.SerializableTypes.RectInt:
 0808                    RemoveColumnInternal(ref AllRectIntColumns, Serializable.SerializableTypes.RectInt, columnID);
 0809                    break;
 810                case Serializable.SerializableTypes.Color:
 0811                    RemoveColumnInternal(ref AllColorColumns, Serializable.SerializableTypes.Color, columnID);
 0812                    break;
 813                case Serializable.SerializableTypes.LayerMask:
 0814                    RemoveColumnInternal(ref AllLayerMaskColumns, Serializable.SerializableTypes.LayerMask, columnID);
 0815                    break;
 816                case Serializable.SerializableTypes.Bounds:
 0817                    RemoveColumnInternal(ref AllBoundsColumns, Serializable.SerializableTypes.Bounds, columnID);
 0818                    break;
 819                case Serializable.SerializableTypes.BoundsInt:
 0820                    RemoveColumnInternal(ref AllBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, columnID);
 0821                    break;
 822                case Serializable.SerializableTypes.Hash128:
 0823                    RemoveColumnInternal(ref AllHash128Columns, Serializable.SerializableTypes.Hash128, columnID);
 0824                    break;
 825                case Serializable.SerializableTypes.Gradient:
 0826                    RemoveColumnInternal(ref AllGradientColumns, Serializable.SerializableTypes.Gradient, columnID);
 0827                    break;
 828                case Serializable.SerializableTypes.AnimationCurve:
 0829                    RemoveColumnInternal(ref AllAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve,
 830                        columnID);
 0831                    break;
 832                case Serializable.SerializableTypes.Object:
 0833                    RemoveColumnInternal(ref AllObjectRefColumns, Serializable.SerializableTypes.Object, columnID);
 0834                    break;
 835            }
 0836        }
 837
 838        // Set
 839
 840        public override ulong SetString(int row, int column, string value)
 0841        {
 0842            return SetCell(row, column, ref AllStringColumns, value);
 0843        }
 844
 845        public override ulong SetBool(int row, int column, bool value)
 0846        {
 0847            return SetCell(row, column, ref AllBoolColumns, value);
 0848        }
 849
 850        public override ulong SetChar(int row, int column, char value)
 0851        {
 0852            return SetCell(row, column, ref AllCharColumns, value);
 0853        }
 854
 855        public override ulong SetSByte(int row, int column, sbyte value)
 0856        {
 0857            return SetCell(row, column, ref AllSbyteColumns, value);
 0858        }
 859
 860        public override ulong SetByte(int row, int column, byte value)
 0861        {
 0862            return SetCell(row, column, ref AllByteColumns, value);
 0863        }
 864
 865        public override ulong SetShort(int row, int column, short value)
 0866        {
 0867            return SetCell(row, column, ref AllShortColumns, value);
 0868        }
 869
 870        public override ulong SetUShort(int row, int column, ushort value)
 0871        {
 0872            return SetCell(row, column, ref AllUshortColumns, value);
 0873        }
 874
 875        public override ulong SetInt(int row, int column, int value)
 0876        {
 0877            return SetCell(row, column, ref AllIntColumns, value);
 0878        }
 879
 880        public override ulong SetUInt(int row, int column, uint value)
 0881        {
 0882            return SetCell(row, column, ref AllUintColumns, value);
 0883        }
 884
 885        public override ulong SetLong(int row, int column, long value)
 0886        {
 0887            return SetCell(row, column, ref AllLongColumns, value);
 0888        }
 889
 890        public override ulong SetULong(int row, int column, ulong value)
 0891        {
 0892            return SetCell(row, column, ref AllUlongColumns, value);
 0893        }
 894
 895        public override ulong SetFloat(int row, int column, float value)
 0896        {
 0897            return SetCell(row, column, ref AllFloatColumns, value);
 0898        }
 899
 900        public override ulong SetDouble(int row, int column, double value)
 0901        {
 0902            return SetCell(row, column, ref AllDoubleColumns, value);
 0903        }
 904
 905        public override ulong SetVector2(int row, int column, Vector2 value)
 0906        {
 0907            return SetCell(row, column, ref AllVector2Columns, value);
 0908        }
 909
 910        public override ulong SetVector3(int row, int column, Vector3 value)
 0911        {
 0912            return SetCell(row, column, ref AllVector3Columns, value);
 0913        }
 914
 915        public override ulong SetVector4(int row, int column, Vector4 value)
 0916        {
 0917            return SetCell(row, column, ref AllVector4Columns, value);
 0918        }
 919
 920        public override ulong SetVector2Int(int row, int column, Vector2Int value)
 0921        {
 0922            return SetCell(row, column, ref AllVector2IntColumns, value);
 0923        }
 924
 925        public override ulong SetVector3Int(int row, int column, Vector3Int value)
 0926        {
 0927            return SetCell(row, column, ref AllVector3IntColumns, value);
 0928        }
 929
 930        public override ulong SetQuaternion(int row, int column, Quaternion value)
 0931        {
 0932            return SetCell(row, column, ref AllQuaternionColumns, value);
 0933        }
 934
 935        public override ulong SetRect(int row, int column, Rect value)
 0936        {
 0937            return SetCell(row, column, ref AllRectColumns, value);
 0938        }
 939
 940        public override ulong SetRectInt(int row, int column, RectInt value)
 0941        {
 0942            return SetCell(row, column, ref AllRectIntColumns, value);
 0943        }
 944
 945        public override ulong SetColor(int row, int column, Color value)
 0946        {
 0947            return SetCell(row, column, ref AllColorColumns, value);
 0948        }
 949
 950        public override ulong SetLayerMask(int row, int column, LayerMask value)
 0951        {
 0952            return SetCell(row, column, ref AllLayerMaskColumns, value);
 0953        }
 954
 955        public override ulong SetBounds(int row, int column, Bounds value)
 0956        {
 0957            return SetCell(row, column, ref AllBoundsColumns, value);
 0958        }
 959
 960        public override ulong SetBoundsInt(int row, int column, BoundsInt value)
 0961        {
 0962            return SetCell(row, column, ref AllBoundsIntColumns, value);
 0963        }
 964
 965        public override ulong SetHash128(int row, int column, Hash128 value)
 0966        {
 0967            return SetCell(row, column, ref AllHash128Columns, value);
 0968        }
 969
 970        public override ulong SetGradient(int row, int column, Gradient value)
 0971        {
 0972            return SetCell(row, column, ref AllGradientColumns, value);
 0973        }
 974
 975        public override ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0976        {
 0977            return SetCell(row, column, ref AllAnimationCurveColumns, value);
 0978        }
 979
 980        public override ulong SetObject(int row, int column, Object value)
 0981        {
 0982            return SetCell(row, column, ref AllObjectRefColumns, value);
 0983        }
 984
 985        public void SetTypeNameForObjectColumn<T>(int columnID) where T : Object
 0986        {
 0987            AssertObjectColumnIDValid(columnID);
 0988            int denseIndex = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 0989            AllObjectRefTypeNames[denseIndex] = typeof(T).AssemblyQualifiedName;
 0990        }
 991
 992        // Get
 993        public override string GetString(int row, int column)
 0994        {
 0995            return GetCell(row, column, ref AllStringColumns);
 0996        }
 997
 998        public override bool GetBool(int row, int column)
 0999        {
 01000            return GetCell(row, column, ref AllBoolColumns);
 01001        }
 1002
 1003        public override char GetChar(int row, int column)
 01004        {
 01005            return GetCell(row, column, ref AllCharColumns);
 01006        }
 1007
 1008        public override sbyte GetSByte(int row, int column)
 01009        {
 01010            return GetCell(row, column, ref AllSbyteColumns);
 01011        }
 1012
 1013        public override byte GetByte(int row, int column)
 01014        {
 01015            return GetCell(row, column, ref AllByteColumns);
 01016        }
 1017
 1018        public override short GetShort(int row, int column)
 01019        {
 01020            return GetCell(row, column, ref AllShortColumns);
 01021        }
 1022
 1023        public override ushort GetUShort(int row, int column)
 01024        {
 01025            return GetCell(row, column, ref AllUshortColumns);
 01026        }
 1027
 1028        public override int GetInt(int row, int column)
 01029        {
 01030            return GetCell(row, column, ref AllIntColumns);
 01031        }
 1032
 1033        public override uint GetUInt(int row, int column)
 01034        {
 01035            return GetCell(row, column, ref AllUintColumns);
 01036        }
 1037
 1038        public override long GetLong(int row, int column)
 01039        {
 01040            return GetCell(row, column, ref AllLongColumns);
 01041        }
 1042
 1043        public override ulong GetULong(int row, int column)
 01044        {
 01045            return GetCell(row, column, ref AllUlongColumns);
 01046        }
 1047
 1048        public override float GetFloat(int row, int column)
 01049        {
 01050            return GetCell(row, column, ref AllFloatColumns);
 01051        }
 1052
 1053        public override double GetDouble(int row, int column)
 01054        {
 01055            return GetCell(row, column, ref AllDoubleColumns);
 01056        }
 1057
 1058        public override Vector2 GetVector2(int row, int column)
 01059        {
 01060            return GetCell(row, column, ref AllVector2Columns);
 01061        }
 1062
 1063        public override Vector3 GetVector3(int row, int column)
 01064        {
 01065            return GetCell(row, column, ref AllVector3Columns);
 01066        }
 1067
 1068        public override Vector4 GetVector4(int row, int column)
 01069        {
 01070            return GetCell(row, column, ref AllVector4Columns);
 01071        }
 1072
 1073        public override Vector2Int GetVector2Int(int row, int column)
 01074        {
 01075            return GetCell(row, column, ref AllVector2IntColumns);
 01076        }
 1077
 1078        public override Vector3Int GetVector3Int(int row, int column)
 01079        {
 01080            return GetCell(row, column, ref AllVector3IntColumns);
 01081        }
 1082
 1083        public override Quaternion GetQuaternion(int row, int column)
 01084        {
 01085            return GetCell(row, column, ref AllQuaternionColumns);
 01086        }
 1087
 1088        public override Rect GetRect(int row, int column)
 01089        {
 01090            return GetCell(row, column, ref AllRectColumns);
 01091        }
 1092
 1093        public override RectInt GetRectInt(int row, int column)
 01094        {
 01095            return GetCell(row, column, ref AllRectIntColumns);
 01096        }
 1097
 1098        public override Color GetColor(int row, int column)
 01099        {
 01100            return GetCell(row, column, ref AllColorColumns);
 01101        }
 1102
 1103        public override LayerMask GetLayerMask(int row, int column)
 01104        {
 01105            return GetCell(row, column, ref AllLayerMaskColumns);
 01106        }
 1107
 1108        public override Bounds GetBounds(int row, int column)
 01109        {
 01110            return GetCell(row, column, ref AllBoundsColumns);
 01111        }
 1112
 1113        public override BoundsInt GetBoundsInt(int row, int column)
 01114        {
 01115            return GetCell(row, column, ref AllBoundsIntColumns);
 01116        }
 1117
 1118        public override Hash128 GetHash128(int row, int column)
 01119        {
 01120            return GetCell(row, column, ref AllHash128Columns);
 01121        }
 1122
 1123        public override Gradient GetGradient(int row, int column)
 01124        {
 01125            return GetCell(row, column, ref AllGradientColumns);
 01126        }
 1127
 1128        public override AnimationCurve GetAnimationCurve(int row, int column)
 01129        {
 01130            return GetCell(row, column, ref AllAnimationCurveColumns);
 01131        }
 1132
 1133        public override Object GetObject(int row, int column)
 01134        {
 01135            return GetCell(row, column, ref AllObjectRefColumns);
 01136        }
 1137
 1138        // Get ref
 1139
 1140        public ref string GetStringRef(int row, int column)
 01141        {
 01142            return ref GetCellRef(row, column, ref AllStringColumns);
 01143        }
 1144
 1145        public ref bool GetBoolRef(int row, int column)
 01146        {
 01147            return ref GetCellRef(row, column, ref AllBoolColumns);
 01148        }
 1149
 1150        public ref char GetCharRef(int row, int column)
 01151        {
 01152            return ref GetCellRef(row, column, ref AllCharColumns);
 01153        }
 1154
 1155        public ref sbyte GetSbyteRef(int row, int column)
 01156        {
 01157            return ref GetCellRef(row, column, ref AllSbyteColumns);
 01158        }
 1159
 1160        public ref byte GetByteRef(int row, int columnID)
 01161        {
 01162            return ref GetCellRef(row, columnID, ref AllByteColumns);
 01163        }
 1164
 1165        public ref short GetShortRef(int row, int column)
 01166        {
 01167            return ref GetCellRef(row, column, ref AllShortColumns);
 01168        }
 1169
 1170        public ref ushort GetUshortRef(int row, int column)
 01171        {
 01172            return ref GetCellRef(row, column, ref AllUshortColumns);
 01173        }
 1174
 1175        public ref int GetIntRef(int row, int column)
 01176        {
 01177            return ref GetCellRef(row, column, ref AllIntColumns);
 01178        }
 1179
 1180        public ref uint GetUintRef(int row, int column)
 01181        {
 01182            return ref GetCellRef(row, column, ref AllUintColumns);
 01183        }
 1184
 1185        public ref long GetLongRef(int row, int column)
 01186        {
 01187            return ref GetCellRef(row, column, ref AllLongColumns);
 01188        }
 1189
 1190        public ref ulong GetUlongRef(int row, int column)
 01191        {
 01192            return ref GetCellRef(row, column, ref AllUlongColumns);
 01193        }
 1194
 1195        public ref float GetFloatRef(int row, int column)
 01196        {
 01197            return ref GetCellRef(row, column, ref AllFloatColumns);
 01198        }
 1199
 1200        public ref double GetDoubleRef(int row, int column)
 01201        {
 01202            return ref GetCellRef(row, column, ref AllDoubleColumns);
 01203        }
 1204
 1205        public ref Vector2 GetVector2Ref(int row, int column)
 01206        {
 01207            return ref GetCellRef(row, column, ref AllVector2Columns);
 01208        }
 1209
 1210        public ref Vector3 GetVector3Ref(int row, int column)
 01211        {
 01212            return ref GetCellRef(row, column, ref AllVector3Columns);
 01213        }
 1214
 1215        public ref Vector4 GetVector4Ref(int row, int column)
 01216        {
 01217            return ref GetCellRef(row, column, ref AllVector4Columns);
 01218        }
 1219
 1220        public ref Vector2Int GetVector2IntRef(int row, int column)
 01221        {
 01222            return ref GetCellRef(row, column, ref AllVector2IntColumns);
 01223        }
 1224
 1225        public ref Vector3Int GetVector3IntRef(int row, int column)
 01226        {
 01227            return ref GetCellRef(row, column, ref AllVector3IntColumns);
 01228        }
 1229
 1230        public ref Quaternion GetQuaternionRef(int row, int column)
 01231        {
 01232            return ref GetCellRef(row, column, ref AllQuaternionColumns);
 01233        }
 1234
 1235        public ref Rect GetRectRef(int row, int column)
 01236        {
 01237            return ref GetCellRef(row, column, ref AllRectColumns);
 01238        }
 1239
 1240        public ref RectInt GetRectIntRef(int row, int column)
 01241        {
 01242            return ref GetCellRef(row, column, ref AllRectIntColumns);
 01243        }
 1244
 1245        public ref Color GetColorRef(int row, int column)
 01246        {
 01247            return ref GetCellRef(row, column, ref AllColorColumns);
 01248        }
 1249
 1250        public ref LayerMask GetLayerMaskRef(int row, int column)
 01251        {
 01252            return ref GetCellRef(row, column, ref AllLayerMaskColumns);
 01253        }
 1254
 1255        public ref Bounds GetBoundsRef(int row, int column)
 01256        {
 01257            return ref GetCellRef(row, column, ref AllBoundsColumns);
 01258        }
 1259
 1260        public ref BoundsInt GetBoundsIntRef(int row, int column)
 01261        {
 01262            return ref GetCellRef(row, column, ref AllBoundsIntColumns);
 01263        }
 1264
 1265        public ref Hash128 GetHash128Ref(int row, int column)
 01266        {
 01267            return ref GetCellRef(row, column, ref AllHash128Columns);
 01268        }
 1269
 1270        public ref Gradient GetGradientRef(int row, int column)
 01271        {
 01272            return ref GetCellRef(row, column, ref AllGradientColumns);
 01273        }
 1274
 1275        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 01276        {
 01277            return ref GetCellRef(row, column, ref AllAnimationCurveColumns);
 01278        }
 1279
 1280        public ref Object GetObjectRef(int row, int column)
 01281        {
 01282            return ref GetCellRef(row, column, ref AllObjectRefColumns);
 01283        }
 1284
 1285        // Get Column
 1286
 1287        public string[] GetStringColumn(int column)
 01288        {
 01289            return GetColumn(column, ref AllStringColumns);
 01290        }
 1291
 1292        public bool[] GetBoolColumn(int column)
 01293        {
 01294            return GetColumn(column, ref AllBoolColumns);
 01295        }
 1296
 1297        public char[] GetCharColumn(int column)
 01298        {
 01299            return GetColumn(column, ref AllCharColumns);
 01300        }
 1301
 1302        public sbyte[] GetSbyteColumn(int column)
 01303        {
 01304            return GetColumn(column, ref AllSbyteColumns);
 01305        }
 1306
 1307        public byte[] GetByteColumn(int column)
 01308        {
 01309            return GetColumn(column, ref AllByteColumns);
 01310        }
 1311
 1312        public short[] GetShortColumn(int column)
 01313        {
 01314            return GetColumn(column, ref AllShortColumns);
 01315        }
 1316
 1317        public ushort[] GetUshortColumn(int column)
 01318        {
 01319            return GetColumn(column, ref AllUshortColumns);
 01320        }
 1321
 1322        public int[] GetIntColumn(int column)
 01323        {
 01324            return GetColumn(column, ref AllIntColumns);
 01325        }
 1326
 1327        public uint[] GetUintColumn(int column)
 01328        {
 01329            return GetColumn(column, ref AllUintColumns);
 01330        }
 1331
 1332        public long[] GetLongColumn(int column)
 01333        {
 01334            return GetColumn(column, ref AllLongColumns);
 01335        }
 1336
 1337        public ulong[] GetUlongColumn(int column)
 01338        {
 01339            return GetColumn(column, ref AllUlongColumns);
 01340        }
 1341
 1342        public float[] GetFloatColumn(int column)
 01343        {
 01344            return GetColumn(column, ref AllFloatColumns);
 01345        }
 1346
 1347        public double[] GetDoubleColumn(int column)
 01348        {
 01349            return GetColumn(column, ref AllDoubleColumns);
 01350        }
 1351
 1352        public Vector2[] GetVector2Column(int column)
 01353        {
 01354            return GetColumn(column, ref AllVector2Columns);
 01355        }
 1356
 1357        public Vector3[] GetVector3Column(int column)
 01358        {
 01359            return GetColumn(column, ref AllVector3Columns);
 01360        }
 1361
 1362        public Vector4[] GetVector4Column(int column)
 01363        {
 01364            return GetColumn(column, ref AllVector4Columns);
 01365        }
 1366
 1367        public Vector2Int[] GetVector2IntColumn(int column)
 01368        {
 01369            return GetColumn(column, ref AllVector2IntColumns);
 01370        }
 1371
 1372        public Vector3Int[] GetVector3IntColumn(int column)
 01373        {
 01374            return GetColumn(column, ref AllVector3IntColumns);
 01375        }
 1376
 1377        public Quaternion[] GetQuaternionColumn(int column)
 01378        {
 01379            return GetColumn(column, ref AllQuaternionColumns);
 01380        }
 1381
 1382        public Rect[] GetRectColumn(int column)
 01383        {
 01384            return GetColumn(column, ref AllRectColumns);
 01385        }
 1386
 1387        public RectInt[] GetRectIntColumn(int column)
 01388        {
 01389            return GetColumn(column, ref AllRectIntColumns);
 01390        }
 1391
 1392        public Color[] GetColorColumn(int column)
 01393        {
 01394            return GetColumn(column, ref AllColorColumns);
 01395        }
 1396
 1397        public LayerMask[] GetLayerMaskColumn(int column)
 01398        {
 01399            return GetColumn(column, ref AllLayerMaskColumns);
 01400        }
 1401
 1402        public Bounds[] GetBoundsColumn(int column)
 01403        {
 01404            return GetColumn(column, ref AllBoundsColumns);
 01405        }
 1406
 1407        public BoundsInt[] GetBoundsIntColumn(int column)
 01408        {
 01409            return GetColumn(column, ref AllBoundsIntColumns);
 01410        }
 1411
 1412        public Hash128[] GetHash128Column(int column)
 01413        {
 01414            return GetColumn(column, ref AllHash128Columns);
 01415        }
 1416
 1417        public Gradient[] GetGradientColumn(int column)
 01418        {
 01419            return GetColumn(column, ref AllGradientColumns);
 01420        }
 1421
 1422        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01423        {
 01424            return GetColumn(column, ref AllAnimationCurveColumns);
 01425        }
 1426
 1427        public Object[] GetObjectColumn(int column)
 01428        {
 01429            return GetColumn(column, ref AllObjectRefColumns);
 01430        }
 1431
 1432        // SetOrder
 1433
 1434        public void SetColumnOrder(int columnID, int newSortOrder)
 01435        {
 01436            AssertColumnIDValid(columnID);
 01437            AssertColumnSortOrderValid(newSortOrder);
 01438            int oldSortOrder = ColumnIDToSortOrderMap[columnID];
 01439            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01440            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01441            {
 01442                int columnIDAt = SortedOrderToColumnIDMap[i + iterDirection];
 01443                ColumnIDToSortOrderMap[columnIDAt] = i;
 01444                SortedOrderToColumnIDMap[i] = SortedOrderToColumnIDMap[i + iterDirection];
 01445            }
 1446
 01447            SortedOrderToColumnIDMap[newSortOrder] = columnID;
 01448            ColumnIDToSortOrderMap[columnID] = newSortOrder;
 01449        }
 1450
 1451        public void SetAllColumnOrders(int[] sortedColumnIDs)
 01452        {
 01453            AssertSortedColumnsArgValid(sortedColumnIDs);
 01454            for (int i = 0; i < SortedOrderToColumnIDMap.Length; i++)
 01455            {
 01456                int columnID = sortedColumnIDs[i];
 01457                SortedOrderToColumnIDMap[i] = columnID;
 01458                ColumnIDToSortOrderMap[columnID] = i;
 01459            }
 01460        }
 1461
 1462        public void SetRowOrder(int rowID, int newSortOrder)
 01463        {
 01464            AssertRowIDValid(rowID);
 01465            AssertRowSortOrderValid(newSortOrder);
 1466
 01467            int oldSortOrder = RowIDToDenseIndexMap[rowID];
 01468            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 1469
 01470            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01471            {
 01472                int rowIDAt = RowDenseIndexToIDMap[i + iterDirection];
 01473                RowIDToDenseIndexMap[rowIDAt] = i;
 01474                RowDenseIndexToIDMap[i] = RowDenseIndexToIDMap[i + iterDirection];
 01475            }
 1476
 01477            SetRowOrderForColumns(AllStringColumns, oldSortOrder, newSortOrder);
 01478            SetRowOrderForColumns(AllBoolColumns, oldSortOrder, newSortOrder);
 01479            SetRowOrderForColumns(AllCharColumns, oldSortOrder, newSortOrder);
 01480            SetRowOrderForColumns(AllSbyteColumns, oldSortOrder, newSortOrder);
 01481            SetRowOrderForColumns(AllByteColumns, oldSortOrder, newSortOrder);
 01482            SetRowOrderForColumns(AllShortColumns, oldSortOrder, newSortOrder);
 01483            SetRowOrderForColumns(AllUshortColumns, oldSortOrder, newSortOrder);
 01484            SetRowOrderForColumns(AllIntColumns, oldSortOrder, newSortOrder);
 01485            SetRowOrderForColumns(AllUintColumns, oldSortOrder, newSortOrder);
 01486            SetRowOrderForColumns(AllLongColumns, oldSortOrder, newSortOrder);
 01487            SetRowOrderForColumns(AllUlongColumns, oldSortOrder, newSortOrder);
 01488            SetRowOrderForColumns(AllFloatColumns, oldSortOrder, newSortOrder);
 01489            SetRowOrderForColumns(AllDoubleColumns, oldSortOrder, newSortOrder);
 01490            SetRowOrderForColumns(AllVector2Columns, oldSortOrder, newSortOrder);
 01491            SetRowOrderForColumns(AllVector3Columns, oldSortOrder, newSortOrder);
 01492            SetRowOrderForColumns(AllVector4Columns, oldSortOrder, newSortOrder);
 01493            SetRowOrderForColumns(AllVector2IntColumns, oldSortOrder, newSortOrder);
 01494            SetRowOrderForColumns(AllVector3IntColumns, oldSortOrder, newSortOrder);
 01495            SetRowOrderForColumns(AllQuaternionColumns, oldSortOrder, newSortOrder);
 01496            SetRowOrderForColumns(AllRectColumns, oldSortOrder, newSortOrder);
 01497            SetRowOrderForColumns(AllRectIntColumns, oldSortOrder, newSortOrder);
 01498            SetRowOrderForColumns(AllColorColumns, oldSortOrder, newSortOrder);
 01499            SetRowOrderForColumns(AllLayerMaskColumns, oldSortOrder, newSortOrder);
 01500            SetRowOrderForColumns(AllBoundsColumns, oldSortOrder, newSortOrder);
 01501            SetRowOrderForColumns(AllBoundsIntColumns, oldSortOrder, newSortOrder);
 01502            SetRowOrderForColumns(AllHash128Columns, oldSortOrder, newSortOrder);
 01503            SetRowOrderForColumns(AllGradientColumns, oldSortOrder, newSortOrder);
 01504            SetRowOrderForColumns(AllAnimationCurveColumns, oldSortOrder, newSortOrder);
 01505            SetRowOrderForColumns(AllObjectRefColumns, oldSortOrder, newSortOrder);
 01506        }
 1507
 1508        public void SetAllRowOrders(int[] sortedRowIDs)
 01509        {
 01510            AssertSortRowsArgValid(sortedRowIDs);
 1511
 01512            ReSortRows(AllStringColumns, sortedRowIDs);
 01513            ReSortRows(AllBoolColumns, sortedRowIDs);
 01514            ReSortRows(AllCharColumns, sortedRowIDs);
 01515            ReSortRows(AllSbyteColumns, sortedRowIDs);
 01516            ReSortRows(AllByteColumns, sortedRowIDs);
 01517            ReSortRows(AllShortColumns, sortedRowIDs);
 01518            ReSortRows(AllUshortColumns, sortedRowIDs);
 01519            ReSortRows(AllIntColumns, sortedRowIDs);
 01520            ReSortRows(AllUintColumns, sortedRowIDs);
 01521            ReSortRows(AllLongColumns, sortedRowIDs);
 01522            ReSortRows(AllUlongColumns, sortedRowIDs);
 01523            ReSortRows(AllFloatColumns, sortedRowIDs);
 01524            ReSortRows(AllDoubleColumns, sortedRowIDs);
 01525            ReSortRows(AllVector2Columns, sortedRowIDs);
 01526            ReSortRows(AllVector3Columns, sortedRowIDs);
 01527            ReSortRows(AllVector4Columns, sortedRowIDs);
 01528            ReSortRows(AllVector2IntColumns, sortedRowIDs);
 01529            ReSortRows(AllVector3IntColumns, sortedRowIDs);
 01530            ReSortRows(AllQuaternionColumns, sortedRowIDs);
 01531            ReSortRows(AllRectColumns, sortedRowIDs);
 01532            ReSortRows(AllRectIntColumns, sortedRowIDs);
 01533            ReSortRows(AllColorColumns, sortedRowIDs);
 01534            ReSortRows(AllLayerMaskColumns, sortedRowIDs);
 01535            ReSortRows(AllBoundsColumns, sortedRowIDs);
 01536            ReSortRows(AllBoundsIntColumns, sortedRowIDs);
 01537            ReSortRows(AllHash128Columns, sortedRowIDs);
 01538            ReSortRows(AllGradientColumns, sortedRowIDs);
 01539            ReSortRows(AllAnimationCurveColumns, sortedRowIDs);
 01540            ReSortRows(AllObjectRefColumns, sortedRowIDs);
 1541
 01542            for (int i = 0; i < sortedRowIDs.Length; i++)
 01543            {
 01544                int rowID = sortedRowIDs[i];
 01545                RowDenseIndexToIDMap[i] = rowID;
 01546                RowIDToDenseIndexMap[rowID] = i;
 01547            }
 01548        }
 1549
 1550        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01551        {
 01552            int columnCount = columns?.Length ?? 0;
 01553            for (int i = 0; i < columnCount; i++)
 01554            {
 01555                T[] column = columns[i].TArray;
 01556                T[] newColumn = new T[column.Length];
 01557                for (int j = 0; j < sortedRowIDs.Length; j++)
 01558                {
 01559                    int rowID = sortedRowIDs[j];
 01560                    int oldRowIndex = RowIDToDenseIndexMap[rowID];
 1561
 01562                    newColumn[j] = column[oldRowIndex];
 01563                }
 1564
 01565                columns[i].TArray = newColumn;
 01566            }
 01567        }
 1568
 1569        // Internal
 1570
 1571        internal void AddTypeNameEntryForUnityObjectColumn()
 01572        {
 01573            int nameArrayLength = AllObjectRefTypeNames?.Length ?? 0;
 01574            Array.Resize(ref AllObjectRefTypeNames, nameArrayLength + 1);
 01575            AllObjectRefTypeNames[nameArrayLength] = UnityObjectString;
 01576        }
 1577
 1578        internal void RemoveTypeNameEntryForUnityObjectColumn(int columnDenseIndex)
 01579        {
 01580            int nameArrayLength = AllObjectRefTypeNames?.Length ?? 0;
 01581            AllObjectRefTypeNames[columnDenseIndex] = AllObjectRefTypeNames[nameArrayLength];
 01582            Array.Resize(ref AllObjectRefTypeNames, nameArrayLength - 1);
 01583        }
 1584
 1585        internal void AssertObjectColumnIDValid(int columnID)
 01586        {
 01587            AssertColumnIDValid(columnID);
 01588            if (ColumnIDToDenseIndexMap[columnID].ColumnType != Serializable.SerializableTypes.Object)
 01589            {
 01590                throw new ArgumentException("Column ID must correspond to a UnityEngine.Object column.");
 1591            }
 01592        }
 1593
 1594        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType,
 1595            Serializable.SerializableTypes typeIndex, int insertAtColumnID)
 01596        {
 01597            if (insertAtColumnID >= 0)
 01598            {
 01599                AssertColumnIDValid(insertAtColumnID);
 01600            }
 1601
 01602            int columnCount = allColumnsOfType?.Length ?? 0;
 01603            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01604            allColumnsOfType[columnCount].TArray = new T[RowCount];
 1605
 01606            int columnID = ColumnEntriesFreeListHead;
 01607            string[] columnNamesForType = AllColumnNames[(int)typeIndex].TArray;
 01608            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01609            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01610            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 01611            AllColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1612
 1613
 01614            int columnIDToDenseIndexMapLength = ColumnIDToDenseIndexMap?.Length ?? 0;
 01615            if (columnID >= columnIDToDenseIndexMapLength)
 01616            {
 01617                int newSize = columnIDToDenseIndexMapLength * 2;
 01618                newSize = newSize == 0 ? 1 : newSize;
 01619                Array.Resize(ref ColumnIDToDenseIndexMap, newSize);
 01620                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01621                {
 01622                    ref ColumnEntry entry = ref ColumnIDToDenseIndexMap[i];
 01623                    entry.ColumnDenseIndex = i + 1;
 01624                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01625                }
 1626
 01627                Array.Resize(ref ColumnIDToSortOrderMap, newSize);
 01628                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01629                {
 01630                    ColumnIDToSortOrderMap[i] = -1;
 01631                }
 01632            }
 1633
 01634            ColumnEntriesFreeListHead = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 1635
 01636            ref int[] denseIndexToIDMap = ref ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 01637            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01638            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01639            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1640
 01641            ref ColumnEntry newEntry = ref ColumnIDToDenseIndexMap[columnID];
 01642            newEntry.ColumnDenseIndex = denseIndexToIDMapLength;
 01643            newEntry.ColumnType = typeIndex;
 1644
 01645            int insertAtSortedIndex =
 1646                insertAtColumnID < 0 ? CombinedColumnCount : ColumnIDToSortOrderMap[insertAtColumnID];
 01647            Array.Resize(ref SortedOrderToColumnIDMap, CombinedColumnCount + 1);
 01648            for (int i = CombinedColumnCount; i > insertAtSortedIndex; i--)
 01649            {
 01650                int currentColumnID = SortedOrderToColumnIDMap[i - 1];
 01651                SortedOrderToColumnIDMap[i] = currentColumnID;
 01652                ColumnIDToSortOrderMap[currentColumnID] = i;
 01653            }
 1654
 01655            if (typeIndex == Serializable.SerializableTypes.Object)
 01656            {
 01657                AddTypeNameEntryForUnityObjectColumn();
 01658            }
 1659
 01660            ColumnIDToSortOrderMap[columnID] = insertAtSortedIndex;
 01661            SortedOrderToColumnIDMap[insertAtSortedIndex] = columnID;
 1662
 01663            ++CombinedColumnCount;
 01664            DataVersion++;
 1665
 01666            return columnID;
 01667        }
 1668
 1669        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType,
 1670            Serializable.SerializableTypes typeIndex, int columnID)
 01671        {
 01672            AssertColumnIDValid(columnID);
 01673            int columnLocation = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 1674
 01675            int lastIndex = allColumnsOfType.Length - 1;
 01676            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 01677            Array.Resize(ref allColumnsOfType, lastIndex);
 1678
 01679            ref string[] columnNamesOfType = ref AllColumnNames[(int)typeIndex].TArray;
 01680            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01681            Array.Resize(ref columnNamesOfType, lastIndex);
 1682
 01683            int columnOrder = ColumnIDToSortOrderMap[columnID];
 1684
 01685            ref int[] denseIndicesOfType = ref ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 01686            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1687
 01688            ref ColumnEntry sparseIndexToFree = ref ColumnIDToDenseIndexMap[columnID];
 01689            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01690            sparseIndexToFree.ColumnDenseIndex = ColumnEntriesFreeListHead;
 01691            ColumnEntriesFreeListHead = columnID;
 1692
 01693            ColumnIDToDenseIndexMap[sparseIndexToSwap].ColumnDenseIndex = columnLocation;
 01694            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01695            Array.Resize(ref denseIndicesOfType, lastIndex);
 1696
 01697            if (typeIndex == Serializable.SerializableTypes.Object)
 01698            {
 01699                RemoveTypeNameEntryForUnityObjectColumn(columnLocation);
 01700            }
 1701
 01702            for (int i = columnOrder + 1; i < CombinedColumnCount; i++)
 01703            {
 01704                int currentColumnID = SortedOrderToColumnIDMap[i];
 01705                SortedOrderToColumnIDMap[i - 1] = currentColumnID;
 01706                ColumnIDToSortOrderMap[currentColumnID] = i - 1;
 01707            }
 1708
 01709            Array.Resize(ref SortedOrderToColumnIDMap, CombinedColumnCount - 1);
 1710
 01711            --CombinedColumnCount;
 01712            DataVersion++;
 01713        }
 1714
 1715        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt,
 1716            int numberOfNewRows)
 01717        {
 01718            int columnCount = allColumnsOfType?.Length ?? 0;
 01719            for (int i = 0; i < columnCount; i++)
 01720            {
 01721                ref T[] rows = ref allColumnsOfType[i].TArray;
 01722                int newRowCount = RowCount + numberOfNewRows;
 01723                Array.Resize(ref rows, newRowCount);
 01724                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01725                {
 01726                    rows[j] = rows[j - numberOfNewRows];
 01727                }
 1728
 01729                for (int j = 0; j < numberOfNewRows; j++)
 01730                {
 01731                    rows[insertAt + j] = default;
 01732                }
 01733            }
 01734        }
 1735
 1736        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt,
 1737            int numberOfRowsToDelete)
 01738        {
 01739            int columnCount = allColumnsOfType?.Length ?? 0;
 1740
 01741            for (int i = 0; i < columnCount; i++)
 01742            {
 01743                ref T[] rows = ref allColumnsOfType[i].TArray;
 01744                int newRowCount = RowCount - numberOfRowsToDelete;
 1745
 01746                for (int j = removeAt + numberOfRowsToDelete; j < RowCount; j++)
 01747                {
 01748                    rows[j - numberOfRowsToDelete] = rows[j];
 01749                }
 1750
 01751                Array.Resize(ref rows, newRowCount);
 01752            }
 01753        }
 1754
 1755        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01756        {
 01757            AssertColumnIDValid(columnID);
 01758            AssertRowIDValid(rowID);
 01759            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01760            int row = RowIDToDenseIndexMap[rowID];
 01761            return ref allColumnsOfType[column][row];
 01762        }
 1763
 1764        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01765        {
 01766            AssertColumnIDValid(columnID);
 01767            AssertRowIDValid(rowID);
 01768            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01769            int row = RowIDToDenseIndexMap[rowID];
 01770            return allColumnsOfType[column][row];
 01771        }
 1772
 1773        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01774        {
 01775            AssertColumnIDValid(columnID);
 01776            AssertRowIDValid(rowID);
 01777            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01778            int row = RowIDToDenseIndexMap[rowID];
 01779            allColumnsOfType[column][row] = value;
 01780            DataVersion++;
 01781            return DataVersion;
 01782        }
 1783
 1784        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01785        {
 01786            AssertColumnIDValid(columnID);
 01787            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01788            return allColumnsOfType[column].TArray;
 01789        }
 1790
 1791        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01792        {
 01793            int columnCount = columns?.Length ?? 0;
 01794            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01795            for (int i = 0; i < columnCount; i++)
 01796            {
 01797                T[] column = columns[i].TArray;
 1798
 01799                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01800                {
 01801                    column[j] = column[j + iterDirection];
 01802                }
 01803            }
 01804        }
 1805
 1806        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01807        {
 01808            if (sortedColumnIDs == null)
 01809            {
 01810                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1811            }
 1812
 01813            if (sortedColumnIDs.Length != SortedOrderToColumnIDMap.Length)
 01814            {
 01815                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 1816            }
 1817
 01818            for (int i = 0; i < sortedColumnIDs.Length; i++)
 01819            {
 01820                AssertColumnIDValid(sortedColumnIDs[i]);
 01821            }
 01822        }
 1823
 1824        internal void AssertColumnSortOrderValid(int sortedOrder)
 01825        {
 01826            if (sortedOrder >= CombinedColumnCount || sortedOrder < 0)
 01827            {
 01828                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 1829            }
 01830        }
 1831
 1832        internal void AssertRowSortOrderValid(int sortedOrder)
 01833        {
 01834            if (sortedOrder >= RowCount || sortedOrder < 0)
 01835            {
 01836                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 1837            }
 01838        }
 1839
 1840        internal void AssertSortRowsArgValid(int[] sortedRowIDs)
 01841        {
 01842            if (sortedRowIDs == null)
 01843            {
 01844                throw new ArgumentException("sortedRowIDs array cannot be null.");
 1845            }
 1846
 01847            if (sortedRowIDs.Length != RowDenseIndexToIDMap.Length)
 01848            {
 01849                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 1850            }
 1851
 01852            for (int i = 0; i < sortedRowIDs.Length; i++)
 01853            {
 01854                AssertRowIDValid(sortedRowIDs[i]);
 01855            }
 01856        }
 1857
 1858        [Serializable]
 1859        internal struct ColumnEntry
 1860        {
 1861            public Serializable.SerializableTypes ColumnType;
 1862            public int ColumnDenseIndex;
 1863        }
 1864    }
 1865}

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetDisplayName()
SetDisplayName(System.String)
GetFlag(GDX.Tables.TableBase/Flags)
SetFlag(GDX.Tables.TableBase/Flags, System.Boolean)
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
SetAllRowDescriptionsOrder(GDX.Tables.TableBase/RowDescription[])
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
SetAllColumnDescriptionsOrder(GDX.Tables.TableBase/ColumnDescription[])
GetAllColumnDescriptions()
AssertColumnIDValid(System.Int32)
AssertRowIDValid(System.Int32)
SetColumnName(System.String, System.Int32)
GetColumnName(System.Int32)
SetRowName(System.String, System.Int32)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
SetTypeNameForObjectColumn[T](System.Int32)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddTypeNameEntryForUnityObjectColumn()
RemoveTypeNameEntryForUnityObjectColumn(System.Int32)
AssertObjectColumnIDValid(System.Int32)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSortRowsArgValid(System.Int32[])